﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Diagnostics;
using System.Runtime.InteropServices;

namespace Helper
{
    /// <summary>
    /// 条码扫描器助手类
    /// 使用Windows低级键盘钩子技术捕获扫描枪输入
    /// 自动识别连续扫描输入并解析为条码字符串
    /// </summary>
    public class BarcodeScannerHelper
    {
        // 定义扫描事件委托 - 用于在扫描到条码时触发事件
        //public delegate void ScanerDelegate(ScanerCodes codes);
        public delegate void ScanerDelegate(string codes);

        // 声明扫描事件 - 当扫描器完成条码扫描时触发
        public event ScanerDelegate ScanerEvent;

        // 键盘消息常量定义（已注释，供参考）
        //private const int WM_KEYDOWN = 0x100;//KEYDOWN
        //private const int WM_KEYUP = 0x101;//KEYUP
        //private const int WM_SYSKEYDOWN = 0x104;//SYSKEYDOWN
        //private const int WM_SYSKEYUP = 0x105;//SYSKEYUP
        //private static int HookProc(int nCode, Int32 wParam, IntPtr lParam);

        /// <summary>
        /// 键盘钩子句柄 - 用于标识和操作键盘钩子
        /// </summary>
        private int hKeyboardHook = 0;

        // 条码扫描处理核心类实例 - 用于收集和处理键盘输入
        private ScanerCodes codes = new ScanerCodes();//13为键盘钩子

        // 定义成静态，这样不会抛出回收异常
        private static HookProc hookproc;

        // 钩子过程委托定义 - 用于处理键盘钩子回调
        delegate int HookProc(int nCode, Int32 wParam, IntPtr lParam);

        // 导入user32.dll系统API - 设置Windows钩子
        [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        //设置钩子（设立一道卡子，盘查需要的信息）
        private static extern int SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr hInstance, int threadId);

        // 导入user32.dll系统API - 卸载Windows钩子
        [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        //卸载钩子 （卸载很重要，卡子设多了会造成拥堵）
        private static extern bool UnhookWindowsHookEx(int idHook);

        // 导入user32.dll系统API - 将钩子信息传递给链中的下一个钩子
        [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        //继续下个钩子 用于传递钩子（消息是重要的，所以从哪里来，就应该回到哪里去，除非你决定要封锁消息）
        private static extern int CallNextHookEx(int idHook, int nCode, Int32 wParam, IntPtr lParam);

        // 导入user32.dll系统API - 获取按键名称文本
        [DllImport("user32", EntryPoint = "GetKeyNameText")]
        private static extern int GetKeyNameText(int IParam, StringBuilder lpBuffer, int nSize);

        // 导入user32.dll系统API - 获取键盘状态
        [DllImport("user32", EntryPoint = "GetKeyboardState")]
        //获取按键的状态
        private static extern int GetKeyboardState(byte[] pbKeyState);

        // 导入user32.dll系统API - 将虚拟键码转换为ASCII字符
        [DllImport("user32", EntryPoint = "ToAscii")]
        //ToAscii职能的转换指定的虚拟键码和键盘状态的相应字符或字符
        private static extern bool ToAscii(int VirtualKey, int ScanCode, byte[] lpKeySate, ref uint lpChar, int uFlags);

        // API函数参数说明（已注释）：
        //int VirtualKey //[in] 指定虚拟关键代码进行翻译。
        //int uScanCode, // [in] 指定的硬件扫描码的关键须翻译成英文。高阶位的这个值设定的关键，如果是（不压）
        //byte[] lpbKeyState, // [in] 指针，以256字节数组，包含当前键盘的状态。每个元素（字节）的数组包含状态的一个关键。如果高阶位的字节是一套，关键是下跌（按下）。在低比特，如/果设置表明，关键是对切换。在此功能，只有肘位的CAPS LOCK键是相关的。在切换状态的NUM个锁和滚动锁定键被忽略。
        //byte[] lpwTransKey, // [out] 指针的缓冲区收到翻译字符或字符。
        //uint fuState); // [in] Specifies whether a menu is active. This parameter must be 1 if a menu is active, or 0 otherwise.

        // 导入kernel32.dll系统API - 获取模块句柄
        [DllImport("kernel32.dll")]
        //使用WINDOWS API函数代替获取当前实例的函数,防止钩子失效
        public static extern IntPtr GetModuleHandle(string name);

        /// <summary>
        /// 默认构造函数
        /// </summary>
        public BarcodeScannerHelper()
        {
        }

        /// <summary>
        /// 启动键盘钩子监听
        /// 开始捕获键盘输入用于条码扫描识别
        /// </summary>
        /// <returns>启动成功返回true，失败返回false</returns>
        public bool Start()
        {
            // 检查钩子是否已启动，避免重复启动
            if (hKeyboardHook == 0)
            {
                // 创建钩子过程委托实例
                hookproc = new HookProc(KeyboardHookProc);

                //GetModuleHandle 函数 替代 Marshal.GetHINSTANCE 
                //防止在 framework4.0中 注册钩子不成功 
                IntPtr modulePtr = GetModuleHandle(Process.GetCurrentProcess().MainModule.ModuleName);

                //WH_KEYBOARD_LL=13 - 设置低级键盘钩子
                //全局钩子 WH_KEYBOARD_LL 
                //  hKeyboardHook = SetWindowsHookEx(13, hookproc, Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly().GetModules()[0]), 0); 
                hKeyboardHook = SetWindowsHookEx(13, hookproc, modulePtr, 0);
            }
            return (hKeyboardHook != 0);
        }

        /// <summary>
        /// 停止键盘钩子监听
        /// 释放钩子资源，停止捕获键盘输入
        /// </summary>
        /// <returns>停止成功返回true，失败返回false</returns>
        public bool Stop()
        {
            if (hKeyboardHook != 0)
            {
                // 卸载键盘钩子
                bool retKeyboard = UnhookWindowsHookEx(hKeyboardHook);
                hKeyboardHook = 0;
                return retKeyboard;
            }
            return true;
        }

        /// <summary>
        /// 键盘钩子处理过程
        /// 核心的回调函数，处理所有键盘输入事件
        /// </summary>
        /// <param name="nCode">钩子代码，决定如何处理消息</param>
        /// <param name="wParam">消息类型（按键按下/释放）</param>
        /// <param name="lParam">指向键盘消息结构的指针</param>
        /// <returns>下一个钩子的处理结果</returns>
        private int KeyboardHookProc(int nCode, Int32 wParam, IntPtr lParam)
        {
            // 将指针转换为EventMsg结构体，获取详细的键盘事件信息
            EventMsg msg = (EventMsg)Marshal.PtrToStructure(lParam, typeof(EventMsg));

            // 将键盘事件添加到条码处理器
            codes.Add(msg);

            // 检测到回车键（ASCII 13）且参数有效且有条码结果时触发扫描事件
            if (ScanerEvent != null && msg.message == 13 && msg.paramH > 0 && !string.IsNullOrEmpty(codes.Result))
            {
                //ScanerEvent(codes);
                ScanerEvent(codes.Result);  // 触发扫描事件，传递条码字符串
            }

            // 将消息传递给钩子链中的下一个钩子
            return CallNextHookEx(hKeyboardHook, nCode, wParam, lParam);
        }

        /// <summary>
        /// 条码扫描处理核心类
        /// 负责收集、处理和识别连续的键盘输入为条码字符串
        /// </summary>
        public class ScanerCodes
        {
            private int ts = 100; // 指定输入间隔为100毫秒以内时为连续输入（扫描枪特征）
            private List<List<EventMsg>> _keys = new List<List<EventMsg>>();  // 存储按时间分组的按键事件
            private List<int> _keydown = new List<int>();   // 保存当前按下的键码（组合键状态）
            private List<string> _result = new List<string>();  // 存储解析出的条码结果集
            private DateTime _last = DateTime.Now;  // 记录最后一次按键时间
            private byte[] _state = new byte[256];  // 键盘状态缓冲区（256个键的状态）
            private string _key = string.Empty;     // 当前按键名称
            private string _cur = string.Empty;     // 当前转换后的字符

            /// <summary>
            /// 获取最后一个键盘事件
            /// </summary>
            public EventMsg Event
            {
                get
                {
                    if (_keys.Count == 0)
                    {
                        return new EventMsg();  // 返回空事件
                    }
                    else
                    {
                        // 返回最后一个按键组中的最后一个事件
                        return _keys[_keys.Count - 1][_keys[_keys.Count - 1].Count - 1];
                    }
                }
            }

            /// <summary>
            /// 获取当前按下的键码列表
            /// </summary>
            public List<int> KeyDowns
            {
                get
                {
                    return _keydown;
                }
            }

            /// <summary>
            /// 获取最后一次输入时间
            /// </summary>
            public DateTime LastInput
            {
                get
                {
                    return _last;
                }
            }

            /// <summary>
            /// 获取当前键盘状态
            /// </summary>
            public byte[] KeyboardState
            {
                get
                {
                    return _state;
                }
            }

            /// <summary>
            /// 获取当前按下的键数量
            /// </summary>
            public int KeyDownCount
            {
                get
                {
                    return _keydown.Count;
                }
            }

            /// <summary>
            /// 获取最后解析出的条码结果
            /// 自动去除首尾空白字符
            /// </summary>
            public string Result
            {
                get
                {
                    if (_result.Count > 0)
                    {
                        return _result[_result.Count - 1].Trim();
                    }
                    else
                    {
                        return null;  // 无结果时返回null
                    }
                }
            }

            /// <summary>
            /// 获取当前按键名称
            /// </summary>
            public string CurrentKey
            {
                get
                {
                    return _key;
                }
            }

            /// <summary>
            /// 获取当前转换后的字符
            /// </summary>
            public string CurrentChar
            {
                get
                {
                    return _cur;
                }
            }

            /// <summary>
            /// 判断Shift键是否按下
            /// 160是左Shift键的虚拟键码
            /// </summary>
            public bool isShift
            {
                get
                {
                    return _keydown.Contains(160);
                }
            }

            /// <summary>
            /// 添加并处理键盘事件
            /// 核心方法，负责收集按键并转换为条码字符
            /// </summary>
            /// <param name="msg">键盘事件消息</param>
            public void Add(EventMsg msg)
            {
                #region 记录按键信息（分组逻辑）

                // 首次按下按键 - 初始化第一个按键组
                if (_keys.Count == 0)
                {
                    _keys.Add(new List<EventMsg>());
                    _keys[0].Add(msg);
                    _result.Add(string.Empty);  // 初始化对应的结果字符串
                }
                // 未释放其他按键时按下按键（组合键情况）- 添加到当前按键组
                else if (_keydown.Count > 0)
                {
                    _keys[_keys.Count - 1].Add(msg);
                }
                // 单位时间内按下按键（连续扫描）- 添加到当前按键组
                else if (((TimeSpan)(DateTime.Now - _last)).TotalMilliseconds < ts)
                {
                    _keys[_keys.Count - 1].Add(msg);
                }
                // 超时，开始新的输入序列 - 创建新的按键组
                else
                {
                    _keys.Add(new List<EventMsg>());
                    _keys[_keys.Count - 1].Add(msg);
                    _result.Add(string.Empty);  // 初始化新的结果字符串
                }
                #endregion

                // 更新最后输入时间
                _last = DateTime.Now;

                #region 获取和维护键盘状态
                // 记录正在按下的按键（按键按下事件）
                if (msg.paramH == 0 && !_keydown.Contains(msg.message))
                {
                    _keydown.Add(msg.message);
                }
                // 清除已松开的按键（按键释放事件）
                if (msg.paramH > 0 && _keydown.Contains(msg.message))
                {
                    _keydown.Remove(msg.message);
                }
                #endregion

                #region 计算按键信息（字符转换核心逻辑）

                // 提取虚拟键码和扫描码
                int v = msg.message & 0xff;
                int c = msg.paramL & 0xff;

                // 获取按键名称
                StringBuilder strKeyName = new StringBuilder(500);
                if (GetKeyNameText(c * 65536, strKeyName, 255) > 0)
                {
                    _key = strKeyName.ToString().Trim(new char[] { ' ', '\0' });

                    // 获取当前键盘状态
                    GetKeyboardState(_state);

                    // 处理普通字符按键（按键按下状态且为单字符按键）
                    if (_key.Length == 1 && msg.paramH == 0)// && msg.paramH == 0
                    {
                        // 根据键盘状态和shift状态判断输出字符 
                        _cur = ShiftChar(_key, isShift, _state).ToString();
                        _result[_result.Count - 1] += _cur;  // 追加到当前结果
                    }
                    // 特殊处理：小键盘+号键（备选方案）
                    //判断是+ 强制添加+
                    else if (_key.Length == 5 && msg.paramH == 0 && msg.paramL == 78 && msg.message == 107)// && msg.paramH == 0
                    {
                        // 根据键盘状态和shift缓存判断输出字符 
                        _cur = Convert.ToChar('+').ToString();
                        _result[_result.Count - 1] += _cur;
                    }
                    else
                    {
                        _cur = string.Empty;  // 非字符按键，清空当前字符
                    }
                }
                #endregion
            }

            /// <summary>
            /// 字符Shift状态转换
            /// 根据Shift键状态和CapsLock状态转换字符大小写和符号
            /// </summary>
            /// <param name="k">原始按键字符</param>
            /// <param name="isShiftDown">Shift键是否按下</param>
            /// <param name="state">键盘状态数组</param>
            /// <returns>转换后的字符</returns>
            private char ShiftChar(string k, bool isShiftDown, byte[] state)
            {
                // 获取各种锁定键的状态
                bool capslock = state[0x14] == 1;      // CapsLock状态
                bool numlock = state[0x90] == 1;       // NumLock状态
                bool scrolllock = state[0x91] == 1;    // ScrollLock状态
                bool shiftdown = state[0xa0] == 1;     // Shift键状态

                // 基础字符转换（考虑CapsLock）
                char chr = (capslock ? k.ToUpper() : k.ToLower()).ToCharArray()[0];

                // 如果Shift键按下，进行进一步转换
                if (isShiftDown)
                {
                    // 字母字符大小写转换
                    if (chr >= 'a' && chr <= 'z')
                    {
                        chr = (char)((int)chr - 32);  // 小写转大写
                    }
                    else if (chr >= 'A' && chr <= 'Z')
                    {
                        if (chr == 'Z')
                        {
                            string s = "";  // 调试断点位置
                        }
                        chr = (char)((int)chr + 32);  // 大写转小写
                    }
                    else
                    {
                        // 符号字符转换（普通符号转Shift符号）
                        string s = "`1234567890-=[];',./";     // 普通符号
                        string u = "~!@#$%^&*()_+{}:\"<>?";    // Shift符号
                        if (s.IndexOf(chr) >= 0)
                        {
                            return (u.ToCharArray())[s.IndexOf(chr)];  // 返回对应的Shift符号
                        }
                    }
                }
                return chr;
            }
        }

        /// <summary>
        /// 键盘事件消息结构体
        /// 对应Windows的KBDLLHOOKSTRUCT结构
        /// </summary>
        public struct EventMsg
        {
            public int message;    // 虚拟键码（如：65='A'）
            public int paramL;     // 扫描码和扩展标志
            public int paramH;     // 事件标志（0=按下，1=释放）
            public int Time;       // 消息时间戳
            public int hwnd;       // 窗口句柄
        }
    }
}